// 导入对话历史模型
const chatHistoryModel = require('../models/chatHistoryModel');
const characterModel = require('../models/characterModel');

// 对话控制器类
class ChatController {
  // 获取用户的对话历史列表
  getUserChatHistories(req, res) {
    try {
      const userId = req.user?.id;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 获取用户的所有对话历史
      const histories = chatHistoryModel.getUserChatHistories(userId);
      
      // 丰富对话历史数据（添加角色信息）
      const enrichedHistories = histories.map(history => {
        const character = characterModel.getCharacterById(history.characterId);
        return {
          id: history.id,
          title: history.title,
          characterId: history.characterId,
          characterName: character ? character.name : '未知角色',
          characterAvatar: character ? character.avatar : '',
          messageCount: history.messages.length,
          updatedAt: history.updatedAt
        };
      });
      
      return res.status(200).json({
        histories: enrichedHistories,
        total: enrichedHistories.length
      });
    } catch (error) {
      return res.status(500).json({
        message: '获取对话历史列表失败',
        error: error.message
      });
    }
  }

  // 获取对话历史详情
  getChatHistoryById(req, res) {
    try {
      const userId = req.user?.id;
      const { id } = req.params;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 获取对话历史
      const history = chatHistoryModel.getChatHistoryById(parseInt(id));
      
      if (!history) {
        return res.status(404).json({
          message: '对话历史不存在'
        });
      }
      
      // 检查权限（用户只能查看自己的对话历史）
      if (history.userId !== userId) {
        return res.status(403).json({
          message: '权限不足'
        });
      }
      
      // 获取角色信息
      const character = characterModel.getCharacterById(history.characterId);
      
      // 按照系统提示要求的格式返回数据，messages数组内只包含id、sender、content和timestamp
      return res.status(200).json({
        id: history.id,
        title: history.title,
        characterId: history.characterId,
        characterName: character ? character.name : '未知角色',
        characterAvatar: character ? character.avatar : '',
        messages: history.messages.map(msg => ({
          id: msg.id,
          sender: msg.sender,
          content: msg.content,
          timestamp: msg.timestamp
        })),
        createdAt: history.createdAt,
        updatedAt: history.updatedAt
      });
    } catch (error) {
      return res.status(500).json({
        message: '获取对话历史详情失败',
        error: error.message
      });
    }
  }

  // 创建新的对话
  createChat(req, res) {
    try {
      const userId = req.user?.id;
      const { characterId, title } = req.body;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 验证输入
      if (!characterId) {
        return res.status(400).json({
          message: '角色ID是必填项'
        });
      }
      
      // 检查角色是否存在
      const character = characterModel.getCharacterById(parseInt(characterId));
      if (!character) {
        return res.status(404).json({
          message: '角色不存在'
        });
      }
      
      // 创建新对话
      const newChat = chatHistoryModel.createChatHistory(userId, parseInt(characterId), title);
      
      // 丰富返回数据
      return res.status(201).json({
        message: '对话创建成功',
        chat: {
          id: newChat.id,
          title: newChat.title,
          characterId: newChat.characterId,
          characterName: character.name,
          characterAvatar: character.avatar,
          messages: [],
          createdAt: newChat.createdAt,
          updatedAt: newChat.updatedAt
        }
      });
    } catch (error) {
      return res.status(400).json({
        message: error.message
      });
    }
  }

  // 发送消息
  sendMessage(req, res) {
    try {
      const userId = req.user?.id;
      const { historyId } = req.params;
      const { content, voiceUrl } = req.body;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 验证输入
      if (!content) {
        return res.status(400).json({
          message: '消息内容不能为空'
        });
      }
      
      // 检查对话历史是否存在
      const history = chatHistoryModel.getChatHistoryById(parseInt(historyId));
      if (!history) {
        return res.status(404).json({
          message: '对话历史不存在'
        });
      }
      
      // 检查权限
      if (history.userId !== userId) {
        return res.status(403).json({
          message: '权限不足'
        });
      }
      
      // 添加用户消息
      const userMessage = chatHistoryModel.addMessageToHistory(parseInt(historyId), {
        sender: 'user',
        content,
        voiceUrl,
        updateTitle: history.messages.length === 0
      });
      
      // 这里应该集成AI API来获取角色的回复
      // 由于我们现在使用模拟数据，这里简单返回用户消息和一个模拟的角色回复
      // 实际项目中，这里应该调用阿里云通义千问API
      const mockCharacterReply = {
        id: userMessage.id + 1,
        sender: 'character',
        content: '这是一条模拟的角色回复。在实际项目中，这里会调用AI API生成真实的回复内容。',
        timestamp: new Date().toISOString()
      };
      
      // 添加角色回复到对话历史
      chatHistoryModel.addMessageToHistory(parseInt(historyId), mockCharacterReply);
      
      return res.status(200).json({
        message: '消息发送成功',
        userMessage,
        characterReply: mockCharacterReply
      });
    } catch (error) {
      return res.status(400).json({
        message: error.message
      });
    }
  }

  // 更新对话标题
  updateChatTitle(req, res) {
    try {
      const userId = req.user?.id;
      const { id } = req.params;
      const { title } = req.body;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 验证输入
      if (!title) {
        return res.status(400).json({
          message: '对话标题不能为空'
        });
      }
      
      // 检查对话历史是否存在
      const history = chatHistoryModel.getChatHistoryById(parseInt(id));
      if (!history) {
        return res.status(404).json({
          message: '对话历史不存在'
        });
      }
      
      // 检查权限
      if (history.userId !== userId) {
        return res.status(403).json({
          message: '权限不足'
        });
      }
      
      // 更新对话标题
      const updatedHistory = chatHistoryModel.updateChatHistoryTitle(parseInt(id), title);
      
      return res.status(200).json({
        message: '对话标题更新成功',
        title: updatedHistory.title
      });
    } catch (error) {
      return res.status(400).json({
        message: error.message
      });
    }
  }

  // 删除对话历史
  deleteChatHistory(req, res) {
    try {
      const userId = req.user?.id;
      const { id } = req.params;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 检查对话历史是否存在
      const history = chatHistoryModel.getChatHistoryById(parseInt(id));
      if (!history) {
        return res.status(404).json({
          message: '对话历史不存在'
        });
      }
      
      // 检查权限
      if (history.userId !== userId) {
        return res.status(403).json({
          message: '权限不足'
        });
      }
      
      // 删除对话历史
      const deletedHistory = chatHistoryModel.deleteChatHistory(parseInt(id));
      
      return res.status(200).json({
        message: '对话历史删除成功',
        id: deletedHistory.id
      });
    } catch (error) {
      return res.status(400).json({
        message: error.message
      });
    }
  }

  // 清空对话消息
  clearChatMessages(req, res) {
    try {
      const userId = req.user?.id;
      const { id } = req.params;
      
      if (!userId) {
        return res.status(401).json({
          message: '请先登录'
        });
      }
      
      // 检查对话历史是否存在
      const history = chatHistoryModel.getChatHistoryById(parseInt(id));
      if (!history) {
        return res.status(404).json({
          message: '对话历史不存在'
        });
      }
      
      // 检查权限
      if (history.userId !== userId) {
        return res.status(403).json({
          message: '权限不足'
        });
      }
      
      // 清空对话消息
      chatHistoryModel.clearChatHistoryMessages(parseInt(id));
      
      return res.status(200).json({
        message: '对话消息已清空'
      });
    } catch (error) {
      return res.status(400).json({
        message: error.message
      });
    }
  }
}

// 导出对话控制器实例
module.exports = new ChatController();